home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / pcpilot.exe / lha / SCR.C < prev    next >
Text File  |  1989-01-03  |  15KB  |  537 lines
  1. /* ------------------------------------------------------------------------ */
  2. /*                                SCR.C                                     */
  3. /*             See pg. 162 of Systems Programming in Turbo C                */
  4. /*                                                                          */
  5. /* ------------------------------------------------------------------------ */
  6.  
  7. #include <dos.h>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <mem.h>
  11. #include <ctype.h>
  12.  
  13. #include "kbd.h"
  14. #include "scr.h"
  15.  
  16. void ScrGetMode (struct Mode *ModePtr)
  17. /*
  18.     This function gets the current video mode, number of display columns,
  19.     and video page
  20. */
  21. {
  22.     unsigned char AhHold;
  23.  
  24.     _AH = 15;                        /* BIOS get video mode service */
  25.     geninterrupt (0x10);            /* BIOS video service */
  26.     AhHold = _AH;                    /* AH returns columns */
  27.     ModePtr->VideoMode = _AL;        /* AL returns mode */
  28.     ModePtr->Columns = AhHold;
  29.     ModePtr->VideoPage = _BH;        /* BH returns active page */
  30. }
  31.  
  32.  
  33. void ScrSetMode (struct Mode *ModePtr)
  34. /*
  35.     This function sets the video mode and display page
  36. */
  37. {
  38.     _AH = 0;                        /* BIOS set mode service */
  39.     _AL = ModePtr->VideoMode;        /* BIOS video service */
  40.     geninterrupt (0x10);            /* INT 10H
  41.  
  42.     _AH = 5;                        /* BIOS set active page service */
  43.     _AL = ModePtr->VideoPage;
  44.     geninterrupt (0x10);
  45. }
  46.  
  47.  
  48. void InitScr(void)
  49. {
  50.     if (*(char far *)0x00400049 == 7)    {
  51.         VideoSeg = 0xb000;
  52.         VideoMode = MONO;
  53.     }
  54. }
  55.  
  56. void ScrGetCur (int *Col, int *Row, int Page)
  57. /*
  58.     This function assigns the current cursor position
  59. */
  60. {
  61.     _BH = (unsigned char)Page;
  62.     _AH = 3;                        /* BIOS get cursor position */
  63.     geninterrupt (0x10);
  64.  
  65.     *Row = _DH;
  66.     *Col = _DL;
  67. }
  68.  
  69.  
  70. void ScrSetCur (int Col, int Row, int Page)
  71. /*
  72.     This function the cursor position
  73. */
  74. {
  75.     _BH = (unsigned char)Page;
  76.     _DH = Row;
  77.     _DL = Col;
  78.     _AH = 2;                        /* BIOS set cursor position */
  79.     geninterrupt (0x10);
  80. }
  81.  
  82.  
  83. void ScrGetStyle (int *StartLine, int *StopLine)
  84. /*
  85.     This function determines the current cursor's shape
  86. */
  87. {
  88.     _BH = 0;    /* Get it for page 0, since all pages have same style */
  89.     _AH = 3;                        /* BIOS read cursor position */
  90.     geninterrupt (0x10);
  91.     *StartLine = _CH;
  92.     *StopLine = _CL;
  93. }
  94.  
  95.  
  96. void ScrSetStyle (int StartLine, int StopLine)
  97. /*
  98.     This function sets the cursor shape
  99. */
  100. {
  101.     _CH = StartLine;
  102.     _CL = StopLine;
  103.     _AH = 1;                        /* BIOS set cursor type */
  104.     geninterrupt (0x10);
  105. }
  106.  
  107. int GetKey(void)
  108. {
  109.     return (KbdGetC()&0x00ff);
  110. }
  111.  
  112. /* --------------------------- ScrPush/ScrPop ----------------------------- */
  113.  
  114. #define MAXSCREENS 10
  115.  
  116. static char *BufPtar [MAXSCREENS];    /* Elements of this array point to      */
  117.                                     /* the screen storage buffers on the    */
  118.                                     /* scree stack.                         */
  119. static int BufIdx = -1;                /* Index to BufPtar */
  120.  
  121. int ScrPush (void)
  122. /*
  123.     This fuction saves the contents of the current scree on the screen
  124.     stack.
  125. */
  126. {
  127.     int Vseg;
  128.  
  129.     if (++BufIdx >= MAXSCREENS)        /* Test if maximum stack size exceeded */
  130.         return (MAXTOOSMALL);
  131.                                     /* Allocate heap memory for one screen */
  132.     if ((BufPtar [BufIdx] = malloc (4000)) == NULL)    {
  133.         --BufIdx;                    /* Out of heap memory */
  134.         return (NOHEAP);
  135.     }
  136.  
  137.     if (*(char far *)0x00400049 == 7)    /* Test video mode */
  138.         Vseg = 0xb000;                /* Monochrome video memory */
  139.     else
  140.         Vseg = 0xb800;                /* Color video memory */
  141.  
  142.                                         /* Transfer video memory */
  143.     movedata (Vseg,0,FP_SEG ((char far *)BufPtar [BufIdx]),
  144.                 FP_OFF ((char far *)BufPtar [BufIdx]),4000);
  145.  
  146.     return (NOERROR);
  147. }
  148.  
  149.  
  150. int ScrPop (int Remove)
  151. /*
  152.     This function restores the most recently saved screen on the screen
  153.     stack, and removes the screen from the stack IF 'Remove' is nonzero.
  154. */
  155. {
  156.     int Vseg;
  157.  
  158.     if (BufIdx < 0)                        /* No screens to restore */
  159.         return (STACKEMPTY);
  160.  
  161.     if (*(char far *)0x00400049 == 7)    /* Test video mode */
  162.         Vseg = 0xb000;
  163.     else
  164.         Vseg = 0xb800;
  165.                                         /* Transfer video memory */
  166.     movedata (FP_SEG ((char far *)BufPtar [BufIdx]),
  167.                 FP_OFF ((char far *)BufPtar [BufIdx]), Vseg, 0, 4000);
  168.     if (Remove)                            /* Remove screen from stack */
  169.         free (BufPtar [BufIdx--]);
  170.  
  171.     return (NOERROR);
  172. }
  173.  
  174. /* ------------------------------------------------------------------------ */
  175.  
  176. #include <fcntl.h>
  177. #include <io.h>
  178.  
  179. int ScrReadWindow (char *Buffer, char *FileName)
  180. /*
  181.     This function reads the 4000-byte screen image file specified by
  182.     'FileName' (may contain a full path), into the buffer pointed to by
  183.     'Buffer'.
  184. */
  185. {
  186.     int FileHandle;
  187.  
  188.     if ((FileHandle = open (FileName,O_RDONLY | O_BINARY)) == -1)
  189.         return (OPENERR);
  190.     if (read (FileHandle, Buffer, 4000) != 4000)
  191.         return (READERR);
  192.     if (close (FileHandle) == -1)
  193.         return (CLOSERR);
  194.  
  195.     return (NOERROR);
  196. }
  197.  
  198.  
  199.  
  200. #include <stdarg.h>
  201.  
  202. void PutStr(int Col, int Row, int Attr, char *fmt, ...)
  203. {
  204.     va_list arg_ptr;
  205.     char t[100];
  206.  
  207.     va_start(arg_ptr, fmt);
  208.     vsprintf(t, fmt, arg_ptr);
  209.     ScrPutS(t, Attr, Row, Col);
  210.     va_end(arg_ptr);
  211. }
  212.  
  213. void Scroll(int x, int y, int xx, int yy, int direc, int attr)
  214. {
  215.     union REGS r;
  216.  
  217.     if (direc == 0) r.h.ah = 6;
  218.     else r.h.ah = 7;
  219.  
  220.     r.h.al = 1;
  221.     r.h.ch = y;
  222.     r.h.cl = x;
  223.     r.h.dh = yy;
  224.     r.h.dl = xx;
  225.     r.h.bh = attr;
  226.     int86(0x10, &r, &r);
  227. }
  228.  
  229. void ScrPutBox (int ULC, int ULR, int LRC, int LRR, int Style)
  230. /*
  231.     This function displays a box at the specified coordinates on the screen.
  232.     'Style' may be from 0 to 3.
  233. */
  234. {
  235.     register int i;
  236.     int Delta1, Delta2;
  237.  
  238.                                 /* Store the box characters for each style */
  239.     static char ulc [] = {218,201,213,214};
  240.     static char urc [] = {191,187,184,183};
  241.     static char llc [] = {192,200,212,211};
  242.     static char lrc [] = {217,188,190,189};
  243.     static char hl  [] = {196,205,205,196};
  244.     static char vl  [] = {179,186,179,186};
  245.  
  246.     int Vseg;                /* Segment address for video memory */
  247.     char far *Video;            /* Far pointer to video memory */
  248.  
  249.     Delta1 = (LRC - ULC) * 2;        /* Bytes between 2 vertical lines */
  250.     Delta2 = 160 - Delta1;            /* Bytes between right vertical   */
  251.                                     /* line and left vertical line of */
  252.                                     /* next row.                      */
  253.     if (*(char far *)0x00400049 == 7)    /* Test video mode */
  254.         Vseg = 0xb000;
  255.     else
  256.         Vseg = 0xb800;
  257.  
  258.     Video = MK_FP (Vseg, ULR*160+ULC*2);/* Initialize far pointer to */
  259.                                             /* upper left corner of box  */
  260.     *Video = ulc [Style];                    /* draw upper left corner    */
  261.     Video += 2;                                /* Skip attribute byte ???   */
  262.     for (i=1; i<=LRC-ULC-1; ++i)    {        /* Draw top horizontal line  */
  263.         *Video = hl [Style];
  264.         Video += 2;
  265.     }
  266.     *Video = urc [Style];                    /* Draw upper right corner   */
  267.     Video += Delta2;
  268.     for (i=1; i<=LRR-ULR-1; ++i)    {        /* Draw both vertical lines  */
  269.         *Video = vl [Style];                /* Left vertical line           */
  270.         Video += Delta1;
  271.         *Video = vl [Style];                /* Right vertical line         */
  272.         Video += Delta2;
  273.     }
  274.     *Video = llc [Style];                    /* Draw lower left corner    */
  275.     Video += 2;
  276.     for (i=1; i<=LRC-ULC-1; ++i)    {        /* Draw bottom horiz line    */
  277.         *Video = hl [Style];
  278.         Video +=2;
  279.     }
  280.     *Video = lrc [Style];                    /* Draw lower right corner   */
  281. }
  282.  
  283.  
  284. void StyleBox (int x, int y, int xx, int yy, int Attr)
  285. {
  286.     register int i;
  287.     int Delta1, Delta2;
  288.  
  289.     int Vseg;                    /* Segment address for video memory */
  290.     char far *Video;                /* Far pointer to video memory */
  291.  
  292.     Delta1 = (xx - x) * 2;            /* Bytes between 2 vertical lines */
  293.     Delta2 = 160 - Delta1;            /* Bytes between right vertical   */
  294.                                     /* line and left vertical line of */
  295.                                     /* next row.                      */
  296.     if (*(char far *)0x00400049 == 7)    /* Test video mode */
  297.         Vseg = 0xb000;
  298.     else
  299.         Vseg = 0xb800;
  300.  
  301.     Video = MK_FP (Vseg, y*160+x*2);    /* Initialize far pointer to */
  302.                                             /* upper left corner of box  */
  303.     *Video = 218;                            /* draw upper left corner    */
  304.     Video += 2;                                /* Skip attribute byte ???   */
  305.     for (i=1; i<=xx-x-1; ++i)    {            /* Draw top horizontal line  */
  306.         *Video = 196;
  307.         Video += 2;
  308.     }
  309.     *Video = 183;                            /* Draw upper right corner   */
  310.     Video += Delta2;
  311.     for (i=1; i<=yy-y-1; ++i)    {            /* Draw both vertical lines  */
  312.         *Video = 179;                        /* Left vertical line           */
  313.         Video += De